package com.ftg.learn.chapter14;

import java.util.*;
import java.util.concurrent.LinkedTransferQueue;

/**
 * jdk 1.6 hashmap - > hash冲突  没解决
 * jdk 1.7 hashmap 解决 hash冲突  数组+链表 --> 遍历速度慢了
 * jdk 1.8 hashmap 解决    hash冲突 数组+链表 + 树（红黑树）
 * map 我们发现底层是一个 数组+ 链表的结构 。。。
 *
 *  数组初始长度 : 16
 *
 *  hash(key) :  这个方法是用做什么的?  计算出来key所对应的hash值
 *  DEFAULT_LOAD_FACTOR 系数 因子 :
 *
 *  集合 使用  原理
 *
 *  集合题
 *
 *  红黑树 :  -->
 *  Comparator
 *  Comparable
 * @author kangjx
 * @createTime 2022/8/16
 */
public class LearnMap {

    volatile int a = 9;
    volatile int c = 34;
    volatile int b = 13;
    public static void main(String[] args) {
        //二分 有序  20W
        Map<Integer,String> map1 = new TreeMap<>((x,y)->-(x-y));

        map1.put(23,"a");
        map1.put(27,"b");
        map1.put(21,"c");
        map1.put(25,"d");

        System.out.println(map1);
//        Comparator 函数式接口，用来比较元素大小的
        Student[] stu = new Student[3];
        stu[0] = new Student("王五",3,24);
        stu[1] = new Student("张三",1,23);
        stu[2] = new Student("李四",2,21);
//
//        Arrays.sort(stu, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return -(o1.getAge() - o2.getAge());
//            }
//        });
//
//        //也ok
//        Arrays.sort(stu, Comparator.comparingInt(Student::getAge));
//        Arrays.sort(stu, (x,y)->x.getAge()-y.getAge());
//

        Arrays.sort(stu);

        System.out.println(Arrays.toString(stu));

        //有可能是我们map最底层的那个连表数组
//        transient HashMap.Node<K,V>[] table;
//        final V putVal(int 3373752, K name, V 李石头, boolean false,
//        boolean true) {
//            HashMap.Node<K,V>[] tab; //null
//            HashMap.Node<K,V> p; //null
//            int n =0
//            , i=0
//
//            if ((tab = table) == null || (n = tab.length) == 0)
//                //把表示把我们的map重新计算 长度
//                n = (tab = resize()).length;
//            if ((p = tab[i = (n - 1) & hash]) == null)
//                tab[i] = newNode(hash, key, value, null);
//            else {
//                HashMap.Node<K,V> e; K k;
//                if (p.hash == hash &&
//                        ((k = p.key) == key || (key != null && key.equals(k))))
//                    e = p;
//                else if (p instanceof HashMap.TreeNode)
//                    e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//                else {
//                    for (int binCount = 0; ; ++binCount) {
//                        if ((e = p.next) == null) {
//                            p.next = newNode(hash, key, value, null);
//                            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//                                treeifyBin(tab, hash);
//                            break;
//                        }
//                        if (e.hash == hash &&
//                                ((k = e.key) == key || (key != null && key.equals(k))))
//                            break;
//                        p = e;
//                    }
//                }
//                if (e != null) { // existing mapping for key
//                    V oldValue = e.value;
//                    if (!onlyIfAbsent || oldValue == null)
//                        e.value = value;
//                    afterNodeAccess(e);
//                    return oldValue;
//                }
//            }
//            ++modCount;
//            if (++size > threshold)
//                resize();
//            afterNodeInsertion(evict);
//            return null;
//        }


        //map 如果给定长度  2 次幂  如果不是它自己用代码转换了
        // map 底层结构   node[] 链表加数组
//        Map<String,String> map = new HashMap<>(3);
//        map.put("name","李石头");
//        map.get("name");
//        String key = "name";


    }

    static int MAXIMUM_CAPACITY = 1 << 30;
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

}
